home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / dl_serie / 042 / ltmfprg2 / ltmf_lib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-25  |  13.9 KB  |  481 lines
  1. /* ------------------------------------------------------------------------- */
  2. /* ----- Let 'em Fly! Library ----------- (c) 1991-92 by Oliver Scheel ----- */
  3. /* ------------------------------------------------------------------------- */
  4.  
  5. #include <tos.h>
  6. #include <aes.h>
  7. #include <vdi.h>
  8. #include <portab.h>
  9.  
  10. #include "ltmf_lib.h"
  11.  
  12. /* ------------------------------------------------------------------------- */
  13.  
  14. MLOCAL WORD STDARGS draw_fly _((PARMBLK *pblock));
  15.  
  16. /* ------------------------------------------------------------------------- */
  17.  
  18. LTMFLY    *letemfly = NULL;
  19.  
  20. /* ------------------------------------------------------------------------- */
  21.  
  22. MLOCAL    USERBLK    fly_button = {    draw_fly,
  23.                 0l };
  24.  
  25. MLOCAL    WORD    wk_handle;
  26.  
  27. /* ----- Cookie Jar -------------------------------------------------------- */
  28.  
  29. typedef struct
  30. {
  31.     LONG    id,
  32.         *ptr;
  33. } COOKJAR;
  34.  
  35. /* ------------------------------------------------------------------------- */
  36. /* ----- get_cookie -------------------------------------------------------- */
  37. /* ------------------------------------------------------------------------- */
  38.  
  39. LONG *get_cookie(cookie)
  40. LONG    cookie;
  41. {
  42.     LONG    sav;
  43.     COOKJAR    *cookiejar;
  44.     LONG    i = 0;
  45.  
  46.     sav = Super((void *)1L);
  47.     if(sav == 0L)
  48.         sav = Super(0L);
  49.     cookiejar = *((COOKJAR **)0x05a0l);
  50.     if(sav != -1L)
  51.         Super((void *)sav);
  52.     if(cookiejar)
  53.     {
  54.         while(cookiejar[i].id)
  55.         {
  56.             if(cookiejar[i].id == cookie)
  57.                 return(cookiejar[i].ptr);
  58.             i++;
  59.         }
  60.     }
  61.     return(0l);
  62. }
  63.  
  64. /* ------------------------------------------------------------------------- */
  65. /* ----- ltmf_check -------------------------------------------------------- */
  66. /* ------------------------------------------------------------------------- */
  67. /*
  68. **    WORD ltmf_check(UWORD version)
  69. **
  70. **    Funktion:    Checkt, ob Let 'em Fly! installiert ist und ob es
  71. **            die Mindest-Versionsnummer besitzt.
  72. **
  73. **    Parameter:    version    Enhält die zu prüfende Versionsnummer
  74. **                (es wird ein '>='-Test gemacht!!)
  75. **
  76. **    Return:        TRUE    Let 'em Fly! ist installiert und
  77. **                die Versionsnummer ist ok.
  78. **            FALSE    Entweder nicht installiert oder zu
  79. **                niedrige Versionsnummer.
  80. **
  81. ** ------------------------------------------------------------------------- */
  82.  
  83. WORD ltmf_check(version)
  84. UWORD    version;
  85. {
  86.     if(!letemfly)
  87.         letemfly = (LTMFLY *)get_cookie(0x4C544D46L /*'LTMF'*/); /* !gcc! */
  88.     if(letemfly && (letemfly->version >= version))
  89.         return(TRUE);
  90.     else
  91.         return(FALSE);
  92. }
  93.  
  94. /* ------------------------------------------------------------------------- */
  95. /* ----- di_fly ------------------------------------------------------------ */
  96. /* ------------------------------------------------------------------------- */
  97. /*
  98. **    WORD di_fly(OBJECT *tree)
  99. **
  100. **    Funktion:    Läßt Dialoge fliegen ...
  101. **
  102. **    Parameter:    *tree    Enthält die Adresse des Objekt-Baums
  103. **                der fliegen soll.
  104. **
  105. **    Return:        TRUE    Let 'em Fly! ist installiert.
  106. **            FALSE    Let 'em Fly! ist NICHT installiert.
  107. **
  108. ** ------------------------------------------------------------------------- */
  109.  
  110. WORD di_fly(tree)
  111. OBJECT    *tree;
  112. {
  113.     if(ltmf_check(0x0100))
  114.         letemfly->di_fly(tree);
  115.     return(letemfly != 0l);
  116. }
  117.  
  118. /* ------------------------------------------------------------------------- */
  119. /* ----- obj_clsize -------------------------------------------------------- */
  120. /* ------------------------------------------------------------------------- */
  121. /*
  122. **    WORD obj_clsize(OBJECT *tree, WORD obj,
  123. **            WORD *x, WORD *y, WORD *w, WORD *h)
  124. **
  125. **    Funktion:    Berechnet die ECHTEN Ausmaße eines Objekts, d.h.
  126. **            auch SHADOWED-Objekte werden korrekt behandelt.
  127. **
  128. **    Parameter:    *tree    Enthält die Adresse des Objekt-Baums ...
  129. **            obj    und hier die entsprechende Objekt-Nr.
  130. **            *x, *y,    In diesen Variablen steht dann das Ergebnis.
  131. **            *w, *h
  132. **
  133. **    Return:        siehe di_fly()
  134. **
  135. ** ------------------------------------------------------------------------- */
  136.  
  137. WORD obj_clsize(tree, obj, x, y, w, h)
  138. OBJECT    *tree;
  139. WORD    obj;
  140. WORD    *x, *y, *w, *h;
  141. {
  142.     if(ltmf_check(0x0110))
  143.         letemfly->obj_clsize(tree, obj, x, y, w, h);
  144.     return(letemfly != 0l);
  145. }
  146.  
  147. /* ------------------------------------------------------------------------- */
  148. /* ----- init_keys --------------------------------------------------------- */
  149. /* ------------------------------------------------------------------------- */
  150. /*
  151. **    WORD init_keys(OBJECT *tree)
  152. **
  153. **    Funktion:    Weist den Objekten ein Tastenkürzel zu (initialisert
  154. **            also die interne Tabelle) und malt den Strich. Die
  155. **            Funktion wird durch den Schalter 'Key Dials' und die
  156. **            ExObTypes beeinflußt!
  157. **
  158. **    Parameter:    *tree    Enthält die Adresse des entsprechenden
  159. **                Object-Baums.
  160. **
  161. **    Return:        TRUE    Key Dials aktiv, können also angesprochen
  162. **                werden.
  163. **            FALSE    Key Dials inaktiv.
  164. **
  165. ** ------------------------------------------------------------------------- */
  166.  
  167. WORD init_keys(tree)
  168. OBJECT    *tree;
  169. {
  170.     WORD    ret;
  171.  
  172.     if(ltmf_check(0x0113))
  173.     {
  174.         wind_update(BEG_UPDATE);
  175.         ret = letemfly->init_keys(tree);
  176.         wind_update(END_UPDATE);
  177.         return(ret);
  178.     }
  179.     else
  180.         return(FALSE);
  181. }
  182.  
  183. /* ------------------------------------------------------------------------- */
  184. /* ----- lookup_key -------------------------------------------------------- */
  185. /* ------------------------------------------------------------------------- */
  186. /*
  187. **    WORD lookup_key(WORD key, WORD kbshift)
  188. **
  189. **    Funktion:    Gibt zu einer Taste das entsprechende Objekt zurück.
  190. **            Darf nur benutzt werden, wenn init_keys() TRUE
  191. **            zurückgeliefert hat.
  192. **
  193. **    Parameter:    key    Enthält den ASCII/Scancode der Taste. Ist
  194. **                identisch mit dem von evnt_keybd().
  195. **            kbshift    Enthält den Shift-Status (siehe evnt_button()).
  196. **
  197. **    Return:        Objekt-Nr. bzw. 0 falls kein Objekt zugewiesen werden
  198. **            konnte.
  199. **
  200. ** ------------------------------------------------------------------------- */
  201.  
  202. WORD lookup_key(key, kbshift)
  203. WORD    key,
  204.     kbshift;
  205. {
  206.     if(ltmf_check(0x0113))
  207.         return(letemfly->lookup_key(key, kbshift));
  208.     else
  209.         return(FALSE);
  210. }
  211.  
  212. /* ------------------------------------------------------------------------- */
  213. /* ----- set_do_key -------------------------------------------------------- */
  214. /* ------------------------------------------------------------------------- */
  215. /*
  216. **    WORD set_do_key(VOID (*key_handler)())
  217. **
  218. **    Funktion:    Installiert einen zusätzlichen Key-Handler
  219. **            für form_do().
  220. **
  221. **    Parameter:    key_handler    Enthält die Adresse der Funktion des
  222. **                    Key-handlers.
  223. **
  224. **    Return:        TRUE    Handler konnte installiert werden.
  225. **            FALSE    Handler konnte nicht installiert werden.
  226. **
  227. ** ------------------------------------------------------------------------- */
  228.  
  229. WORD set_do_key(key_handler)
  230. WORD STDARGS    (*key_handler)();
  231. {
  232.     if(ltmf_check(0x0112))
  233.     {
  234.         letemfly->do_key = key_handler;
  235.         return(TRUE);
  236.     }
  237.     else
  238.         return(FALSE);
  239. }
  240.  
  241. /* ------------------------------------------------------------------------- */
  242. /* ----- di_moveto --------------------------------------------------------- */
  243. /* ------------------------------------------------------------------------- */
  244. /*
  245. **    WORD di_moveto(OBJECT *tree, WORD x, WORD y)
  246. **
  247. **    Funktion:    Bewegt eine Dialogbox zu einer bestimmten Position.
  248. **
  249. **    Parameter:    *tree    Der Objektbaum
  250. **            x, y    Die Zielkoordinaten. Wird für x -1 übergeben,
  251. **                so wird nur geprüft, ob der Dialog flugfähig
  252. **                ist. Bei x = -2 wird gesagt, ob ein Redraw
  253. **                gesendet wird oder nicht.
  254. **
  255. **    Return:        0    Box kann bzw. konnte nicht fliegen.
  256. **            1    Box ist uneingeschränkt flugfähig.
  257. **            2    Box fliegt nur im Sparmodus.
  258. **
  259. ** ------------------------------------------------------------------------- */
  260.  
  261. WORD di_moveto(tree, x, y)
  262. OBJECT    *tree;
  263. WORD    x, y;
  264. {
  265.     if(ltmf_check(0x0115))
  266.         return(letemfly->di_moveto(tree, x, y));
  267.     else
  268.         return(FALSE);
  269. }
  270.  
  271. /* ------------------------------------------------------------------------- */
  272. /* ----- di_center --------------------------------------------------------- */
  273. /* ------------------------------------------------------------------------- */
  274. /*
  275. **    WORD di_center(OBJECT *tree)
  276. **
  277. **    Funktion:    Zentriert einen auf dem Bildschirm befindlichen
  278. **            Dialog (ähnlich di_moveto(), jedoch mit ausgerechneten
  279. **            Werten).
  280. **
  281. **    Parameter:    *tree    Der zu zentrierende Objektbaum bzw. Dialog
  282. **
  283. **    Return:        siehe di_moveto()
  284. **
  285. ** ------------------------------------------------------------------------- */
  286.  
  287. WORD di_center(tree)
  288. OBJECT    *tree;
  289. {
  290.     if(ltmf_check(0x0117))
  291.         return(letemfly->di_center(tree));
  292.     else
  293.         return(FALSE);
  294. }
  295.  
  296. /* ------------------------------------------------------------------------- */
  297. /* ----- ins_spcchar ------------------------------------------------------- */
  298. /* ------------------------------------------------------------------------- */
  299. /*
  300. **    CHAR ins_spcchar(void)
  301. **
  302. **    Funktion:    Bearbeitet eine Auswahlbox für die üblen Zeichen.
  303. **
  304. **    Parameter:    keine
  305. **
  306. **    Return:        Das ausgewählte Zeichen (0 für keine Auswahl)
  307. **
  308. ** ------------------------------------------------------------------------- */
  309.  
  310. CHAR ins_spcchar()
  311. {
  312.     if(ltmf_check(0x0115))
  313.         return(letemfly->ins_spcchar());
  314.     else
  315.         return(FALSE);
  316. }
  317.  
  318. /* ------------------------------------------------------------------------- */
  319. /* ----- hist_insert ------------------------------------------------------- */
  320. /* ------------------------------------------------------------------------- */
  321. /*
  322. **    WORD hist_insert(CHAR *string)
  323. **
  324. **    Funktion:    Fügt einen String in die History ein.
  325. **
  326. **    Parameter:    string    Der einzufügende String.
  327. **
  328. **    Return:        TRUE    String wurde eingefügt.
  329. **            FALSE    String wurde nicht eingefügt.
  330. **
  331. ** ------------------------------------------------------------------------- */
  332.  
  333. WORD hist_insert(string)
  334. CHAR    *string;
  335. {
  336.     if(ltmf_check(0x0116))
  337.         return(letemfly->hist_insert(string));
  338.     else
  339.         return(FALSE);
  340. }
  341.  
  342. /* ------------------------------------------------------------------------- */
  343. /* ----- init_niceline ----------------------------------------------------- */
  344. /* ------------------------------------------------------------------------- */
  345. /*
  346. **    WORD init_niceline(OBJECT *tree)
  347. **
  348. **    Funktion:    Versieht einen Menübaum (auch Popups) mit den
  349. **            Nicelines. Dabei werden alle G_STRINGs, die DISABLED
  350. **            sind und `---' enthalten durch die Nicelines ersetzt.
  351. **
  352. **    Parameter:    Menübaum.
  353. **
  354. **    Return:        TRUE    Let' em Fly! installiert.
  355. **            FALSE    Let' em Fly! nicht installiert.
  356. **
  357. ** ------------------------------------------------------------------------- */
  358.  
  359. WORD init_niceline(tree)
  360. OBJECT    *tree;
  361. {
  362.     if(ltmf_check(0x0118))
  363.     {
  364.         letemfly->init_niceline(tree);
  365.         return(TRUE);
  366.     }
  367.     else
  368.         return(FALSE);
  369. }
  370.  
  371. /* ------------------------------------------------------------------------- */
  372. /* ----- init_flyobj ------------------------------------------------------- */
  373. /* ------------------------------------------------------------------------- */
  374. /*
  375. **    WORD init_flyobj(OBJECT *tree)
  376. **
  377. **    Funktion:    Initialisiert das Flug-Objekt. Es wird dann durch
  378. **            eine Verschiebeecke ersetzt. Der Objektbaum muß
  379. **            mindestens zwei Objekte (ROOT + 1) enthalten.
  380. **            Die Flugecke wird nur bei installiertem Let 'em Fly!
  381. **            initialisiert. Zu beachten ist, daß ein Flugobjekt
  382. **            erst ab Version 1.15 explizit unterstützt wird.
  383. **
  384. **    Parameter:    Objektbaum, in dem das Flugobjekt enthalten ist.
  385. **
  386. **    Return:        TRUE    Es existiert ein Flugobjekt.
  387. **            FALSE    Es existiert kein Flugobjekt.
  388. **
  389. ** ------------------------------------------------------------------------- */
  390.  
  391. WORD init_flyobj(tree)
  392. OBJECT    *tree;
  393. {
  394.     OBJECT    *tr;
  395.     WORD    obj;
  396.     WORD    d;
  397.  
  398.     ltmf_check(0x0100);    /* init 'letemfly' */
  399.     if((tree[ROOT].ob_type & 0xff00) == 0x8900)    /* Magic? */
  400.     {
  401.         obj = 1;    /* ROOT Objekt geht nicht */
  402.         do
  403.         {
  404.             tr = &tree[obj];
  405.             if(tr->ob_type & 0x4000)    /* Flug-Objekt? */
  406.             {
  407.                 tr->ob_type &= 0xff00;
  408.                 tr->ob_type |= G_USERDEF;
  409.                 tr->ob_spec.userblk = &fly_button;
  410.                 wk_handle = graf_handle(&d, &d, &d, &d);
  411.                 return(TRUE);
  412.             }
  413.         }
  414.         while(!(tree[obj++].ob_flags & LASTOB));
  415.     }
  416.     return(FALSE);
  417. }
  418.  
  419.  
  420. WORD STDARGS draw_fly(pblock)
  421. PARMBLK    *pblock;
  422. {
  423.     WORD    attrib[8],
  424.         pxy[8];
  425.     WORD    off;
  426.  
  427.     /* an dieser Stelle u.U. Register sichern */
  428.  
  429.     if(letemfly && !letemfly->config.bypass && letemfly->config.fly)
  430.     {
  431.         vql_attributes(wk_handle, attrib);    /* Attribute sichern */
  432.  
  433.         vswr_mode(wk_handle, MD_REPLACE);
  434.         pxy[0] = pblock->pb_xc;            /* Clipping einstellen */
  435.         pxy[1] = pblock->pb_yc;
  436.         pxy[2] = pblock->pb_xc + pblock->pb_wc - 1;
  437.         pxy[3] = pblock->pb_yc + pblock->pb_hc - 1;
  438.         vs_clip(wk_handle, 1, pxy);
  439.  
  440.         off = (pblock->pb_tree[pblock->pb_obj].ob_state & OUTLINED) ? 3 : 0;
  441.  
  442.         vsl_color(wk_handle, 0);
  443.         vsl_width(wk_handle, 3);
  444.         vsl_type(wk_handle, 1);
  445.         pxy[0] = pxy[2] = pblock->pb_x - off + 1;
  446.         pxy[1] = pblock->pb_y;
  447.         pxy[3] = pxy[5] = pblock->pb_y + pblock->pb_h + off - 2;
  448.         pxy[4] = pblock->pb_x + pblock->pb_w - 1;
  449.         v_pline(wk_handle, 3, pxy);
  450.  
  451. /*        vsl_color(wk_handle, pblock->pb_tree[pblock->pb_obj].ob_spec.obspec.framecol);
  452. */        vsl_color(wk_handle, 1);
  453.         vsl_width(wk_handle, 1);
  454.  
  455.         pxy[0] = pxy[2] = pblock->pb_x + 3 - off;
  456.         pxy[1] = pblock->pb_y;
  457.         pxy[3] = pxy[5] = pblock->pb_y + pblock->pb_h - 4 + off;
  458.         pxy[4] = pblock->pb_x + pblock->pb_w - 1;
  459.         v_pline(wk_handle, 3, pxy);
  460.  
  461.         pxy[0] = pxy[2] = pblock->pb_x - off;
  462.         pxy[1] = pblock->pb_y - off;
  463.         pxy[3] = pxy[5] = pblock->pb_y + pblock->pb_h + off - 1;
  464.         pxy[4] = pblock->pb_x + pblock->pb_w - 1 + off;
  465.         v_pline(wk_handle, 3, pxy);
  466.  
  467.         pxy[0] = pblock->pb_x - off;
  468.         pxy[1] = pblock->pb_y - off;
  469.         pxy[2] = pblock->pb_x + pblock->pb_w + off - 1;
  470.         pxy[3] = pblock->pb_y + pblock->pb_h + off - 1;
  471.         v_pline(wk_handle, 2, pxy);
  472.  
  473.         vsl_type(wk_handle, attrib[0]);
  474.         vsl_color(wk_handle, attrib[1]);
  475.         vsl_width(wk_handle, attrib[3]);
  476.         vswr_mode(wk_handle, attrib[2]);
  477.     }
  478.     /* an dieser Stelle die Register u.U. wieder herstellen */
  479.     return(NONE);        /* nix mehr malen */
  480. }
  481.